/**
 * 传入16进制数, 转换为10进制有符号数
 * FFFFFF94 -> -108
 * 20 -> 32
 * F1 -> -15
 * @param hexString 待转换的16进制数
 * @returns {number}  转换后得10进制数
 */
export function hexToSignedDecimal(hexString) {
  // 将16进制字符串转换为整数
  let num = parseInt(hexString, 16);

  // 计算需要的比特位数
  let bitLength = hexString.length * 4;

  // 检查最高位（符号位）是否为1，如果是，转换为负数
  if (num >= Math.pow(2, bitLength - 1)) {
    num -= Math.pow(2, bitLength);
  }

  return num;
}

/**
 * 传入一个byte数, 例如64, 也可以是16进制字符串, 例如"64", 将其最高位置1
 * @param value
 * @returns {number}
 */
export function setHighestBitToOne(value) {
  // 使用按位或运算符，将最高位设为1
  return value | 0x80;  // 0x80 = 10000000
}

/**
 * 传入一个16进制字符串, 将其转换为2进制字符串
 * @param hexString 16进制字符串
 * @returns {string}  转换后得2进制字符串
 */
export function hexToBinary(hexString) {
  // 检查十六进制字符串是否合法
  if (!/^[0-9a-fA-F]+$/.test(hexString)) {
    throw new Error("Invalid hexadecimal string");
  }

  // 将每个十六进制字符转换为对应的二进制字符串
  let binaryString = '';
  for (let i = 0; i < hexString.length; i++) {
    // 将每个字符转换为十进制后再转换为二进制，并确保4位长度
    binaryString += parseInt(hexString[i], 16).toString(2).padStart(4, '0');
  }

  return binaryString;
}

// 16 进制字符串转 byte
export function hexStringToByte(hexString) {
  // 确保传入的16进制字符串是两位
  if (!/^[0-9a-fA-F]{2}$/.test(hexString)) {
    throw new Error("Hex string must be exactly 2 characters");
  }

  // 将十六进制字符串转换为十进制整数
  return parseInt(hexString, 16);
}

// byte 转 16 进制字符串
export function byteToHexString(byte) {
  // 如果是负数，转换为对应的无符号整数表示
  let hexString = (byte & 0xFF).toString(16).toUpperCase();

  // 保证输出的十六进制字符串是2位，不足补0
  return hexString.padStart(2, '0');
}


// 将十六进制字符串转换为字节数组
export function hexStringToByteArray(hexString) {
  // 检查十六进制字符串是否合法
  if (!/^[0-9a-fA-F]+$/.test(hexString)) {
    throw new Error("Invalid hexadecimal string");
  }

  // 创建存放字节的数组
  const byteArray = [];

  // 每两个字符切分为一个字节
  for (let i = 0; i < hexString.length; i += 2) {
    byteArray.push(parseInt(hexString.substr(i, 2), 16));
  }

  return byteArray;
}

// 将字节数组转换为十六进制字符串
export function byteArrayToHexString(byteArray) {
  return byteArray.map(byte => {
    // 确保每个字节以两位十六进制数输出，不足两位时补零
    return byte.toString(16).padStart(2, '0');
  }).join('');
}

// int类型转16进制字符串
export function intToHexString(intValue, byteLength = 4) {
  // 检查是否为合法整数
  if (!Number.isInteger(intValue)) {
    throw new Error("输入的值不是整数");
  }

  // 处理负数的补码形式
  let hexString;
  if (intValue < 0) {
    // 将负数转化为对应位数的正数补码表示，并截取指定字节的位数
    hexString = (intValue >>> 0).toString(16).toUpperCase();

    // 截取符合 byteLength 的补码字符串
    hexString = hexString.slice(-byteLength * 2);
  } else {
    hexString = intValue.toString(16).toUpperCase();
  }

  // 填充到指定字节长度（不足时前面补0）
  while (hexString.length < byteLength * 2) {
    hexString = '0' + hexString;
  }

  return hexString;
}

// 16进制字符串转int类型
export function hexStringToInt(hexString, byteLength = 4) {
  // 去掉可能的前缀 "0x"
  hexString = hexString.replace(/^0x/i, '');

  // 将十六进制字符串转换为整数
  let intValue = parseInt(hexString, 16);

  // 计算用于判断正负的最大正数阈值
  // 比如 byteLength = 4 时，maxPositiveValue = 0x7FFFFFFF (2147483647)
  // byteLength = 2 时，maxPositiveValue = 0x7FFF (32767)
  const maxPositiveValue = Math.pow(2, byteLength * 8 - 1) - 1;

  // 计算负数的最小值
  // 比如 byteLength = 4 时，negativeOffset = 0x100000000 (4294967296)
  // byteLength = 2 时，negativeOffset = 0x10000 (65536)
  const negativeOffset = Math.pow(2, byteLength * 8);

  // 判断是否为负数，如果超出最大正数阈值则认为是负数
  if (intValue > maxPositiveValue) {
    intValue -= negativeOffset;
  }

  return intValue;
}